/*
给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

示例 1:

输入: 123
输出: 321
 示例 2:

输入: -123
输出: -321
示例 3:

输入: 120
输出: 21
注意:

假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231,  231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-integer
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

执行用时 :0 ms, 在所有 C++ 提交中击败了100.00%的用户
内存消耗 :5.7 MB, 在所有 C++ 提交中击败了100.00%的用户

复杂度分析：
没啥好分析的就走了一个int型的位数的长度,O(1),空间也是O(1)
 题刷的还是太少了。。。。感觉自己写了一坨屎
*/
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;

/*

感觉自己写了个屎山
本意上是想写个传任意长度字符串的，结果中间的arr2int还是用了数学方法，还是会溢出
把arr2int改为reverse就能直接进行逆序操作了，根据类中成员变量a的大小来看能转换100位以内的字符串
class Solution {
    int a[100];

public:
    int reverse(long long  x) {
        bool isPositive = 1;
        if (x < 0) {
            isPositive = 0;
        }
        if (!isPositive) {
            x = -x;
        }
        int len = len_(x);
        int* arr = int2arr(x, len);
        arr = rev(arr, len);
        arr = rmFrontZeros(arr, len);
        long long ans = arr2int(arr, len);
        if (isPositive) {
            return ans > (long long )INT_MAX ? 0 : ans;
        }
        else {
            return ans > -(long long )INT_MIN ? 0 : -ans;
            //ans是正数这里判定要小心些
        }
    }
    int* rmFrontZeros(int* a, int& len) {
        int i = 0;
        while (a[i] == 0) {
            i++;
            len--;
        }
        if (i != 0) {
            memcpy(a, &a[i], len * sizeof(int));
        }
        return a;
    }
    int len_(long long  x) {
        int n = 0;
        while (x) {
            n++;
            x /= 10;
        }
        return n;
    }
    int* int2arr(long long  x, int len) {
        for (int i = len - 1; i >= 0; i--) {
            a[i] = x % 10;
            x /= 10;
        }
        return a;
    }
    int* rev(int* a, int len) {
        int i = 0, j = len - 1;
        while (i < j) {
            swap(a[i], a[j]);
            i++;
            j--;
        }
        return a;
    }
    void swap(int& a, int& b) {
        int tmp = a;
        a = b;
        b = tmp;
    }
    long long  arr2int(int* a, int len) {
        long long ans = 0;
        for (int j = 0; j < len; j++) {
            ans += a[len - j - 1] * pow(j);
        }
        return ans;
    }
    long long pow(int n) {
        long long  ans = 1;
        for (int i = 0; i < n; i++) {
            ans *= 10;
        }
        return ans;
    }
};

*/
//官方解答还是妙呀
class Solution {
public:
    int reverse(int x) {
        int result = 0;
        while ( x != 0) {
            int tail = x%10;
            x /= 10;
            if ( result >(INT_MAX/10) ) {
                return 0;
            }
            if ( result < (INT_MIN/10) ) {
                return 0;
            }
            result = result*10 +tail;
        }
        return result;
    }
};
int main(int argc, char const* argv[]) {
    Solution s;
    long long  a = -2147400000;
    cout << s.reverse(a) << endl;
    //cout << -INT_MIN << endl;		-2147483648
    return 0;
}
